let python=`
#$





#UDP通讯接收端
"pyPython"
import socket
BUFSIZE = 260000
ip_port = ('127.0.0.1', 9999)
server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # udp协议
server.bind(ip_port)
while True:
    data,client_addr = server.recvfrom(BUFSIZE)
    print('server收到的数据', data.decode("utf-8"))
 
    server.sendto(data.upper(),client_addr)
 
server.close()

#$
#添加模块(库)搜索路径
import sys
sys.path.append("./module/...")
#$
    #3.变为监听套接字(监听连接)
    listen_socket.listen(1)
    #设置套接字为非堵塞
    lissen_socket.setblocking(False)
#$
#多任务(多进程)
# -*- coding:utf-8 -*-
from multiprocessing import Process
import os
import time
def run_proc():
""“子进程要执行的代码"""
    print('子进程运行中，pid=ed...’% os.getpid(）） 
    # os.getpid获取当前进程的进程号
    print（'子进程将要结束...'）
if __name__ =="__main__":
    print('父进程pid：&d’% os.getpid()） # os.getpid获取当前进程的进程号
    #multiprocessing.Process()这样
    p = Process(target=run_proc)
    p.start()


#$
#多任务(多线程):
并行:多核CPU一核执行一个程序(真多任务)
并发:单核CPU时间片轮转(优先级调度),每个程序执行0.001秒,快速切换,假的多任务

实例:
#coding=utf-8
import threading
import time
def saySorry():
    print(“亲爱的，我错了，我能吃饭了吗？"）
    time.sleep(1)
if __name__ == "__main__":
    for i in range(5):
    t = threading.Thread(target=saySorry)
    t.start()#启动线程·即让线程开始执行

#$
#多线程之间共享全局变量
global 变量名  #获取全局变量
#$
#互斥锁:
线程操作全局变量时会有资源竞争的问题
解决资源竞争问题:
原子性(要么不做要么做绝)
互斥所：锁定/非锁定
某个线程要更改共享数据时将其锁定,操作完后非锁定,保证了每次只有一个线程操作数据

实例:
inport threading
tmport time
#定义一个全局变量 
g_nun=0
def test1(nun): 
    global g_num
    #上锁，如果之前没有被上锁，那么此时上成功
    #如果上锁之前已经被上锁了，那么此时会堵塞在这里，直到 这个锁被解开位置
    mutex.acquire()
    for i in range(num)：
    nun += 1
    # 解锁
    mutex.release()
    print(g_num)


def test2(num):
    global g_num
    mutex.acquire()#上锁
    for t in range(nun)：
    g_nun+=1
    # 解锁
    mutex.release()
    print(g_nun)


# 创建一个互斥锁，默认是没有上锁的
mutex =threading.Lock()

def natn():
    t1 = threadtng.Thread(target=test1,args=(10000))
    t2=
    t1.start()
#$
#创建线程传参数过去
def add(pr):#接收arr参数
    print(pr)
arr=[11,22]
#target=add#add为函数名
threading.Thread(target=add,args=(arr))
#$
#通过类继承创建线程
#coding=utf-8
import threading
import time
class MyThread(threading.Thread):
def run(self):#线程只执行run方法
    for i in range(3):
    time.sleep(1)
    msg ="I'm"+self.name+’@'+str(i)#name属性中保存的是当前线程的名字
    print(msg)
#这里定义其他方法函数在类里调用
if __name__==  "__main__":
    t = MyThread()
    t.start()

#$
#函数里面修改全局变量
nun=100
arr=[11,22]
def add():
    #变量地址发生变化需要加global获取
    global num
    num+=100
    arr.append(33)#列表添加数据

#$
#查看正在运行的线程
#线程运行不分先后顺序
#threading.enunerate()
print(threading.enumerate())
#$
enunerate()#拆分列表为元祖
实例:
names=["zhabgsangsan","lisi","wang5"]
for i,name in enunerate(names):
    print(i,name)
    #结果为（0,zhabgngsan)这种
    #a,b=(i,name)#拆包


#$
#正则表达式
#模块导入
import re
#re.match(正则表达式,字符串)
re.match(r"hello","helloword")#匹配hello
#$
#匹配单个字符
ret=re.match(r"速度激情\d","速度激情1")
#re.S让.匹配换行\n
ret=re.match(r".*","带换行变量",re.S)
ret.group()#查看匹配的数据

匹配符:        功能
.              #匹配任意一个字符(除\n)
\d             #匹配数字(0-9)
[]             #匹配[]中列举的字符
\D             #匹配非数字
\s             #匹配空白(空格,tab键)
\S             #匹配非空白
\w       #匹配单词字符(a-z,aA-Z,0-9,_)
\W             #匹配非单词字符

[1-8a-zA-Z]      #限制匹配
[1258abc]        #只匹配1258
[1-35-8]         #匹配1-3，5-8
#$
#匹配多个字符
匹配符:        功能
*     #前一个字符0次或无限次(可有可无)
+     #前一个字符1次或无限次(至少1次)
?     #前一个字符0次或1次(0或1)
{m}   #匹配前一个字符出现m次
{m,n} #匹配前一个字符出现m到n次

\d{1,3}         #1到3位数字
\d{11}          #连续的11为数字

#$
#正则匹配,匹配以/9j/开始后面的所有
#匹配任意位置开始后面所有字符串
search_t = re.search( r'/9j/(.*?).*',img_base64, re.M|re.I|re.S).group()

#$
#匹配开头,结尾

符号           功能
^           #匹配开头
$           #匹配结尾(规则完正好匹配完)

r"^{a-zA-Z_}{a-zA-Z_}*$"

实例：匹配邮箱格式

import re

def main():
email =input("请输入一个邮箱地址：")
# 如果在正则表达式中需要用到了某些普通的字符，比如-比如？等，仅仅需要在他们前面添加一个 反斜杠进行转义
if ret: 
    ret =re.matchj(r"[a-zA-Z_0-o]{4,20}@163\.com$",enail)
    print("%s符合要求....”% ematl）
else:
    print("%s不符合要求…..”% emoil）

if __name__=="__main__"
    main()


#$
#匹配分组
符号       功能

|         #匹配左右任意一个表达式
(ab)      #将括号中字符作为一个分组
\num      #引用分组num匹配到的字符
(?P<name>) #分组取别名
(?P=name) #引用别名为name分组匹配到的字符

例子:
ret =re.matchj(r"[a-zA-Z_0-o]{4,20}@(163|126)\.com$",enail)#163或126都行
#取的是匹配成功的数据
#想取那部分数据用()再根据序取数据
str=ret.group(1)#取第一组()里的数据
#$
#re模块高级用法
#不会从头匹配，匹配到数据就停
re.search(r"\d+","阅读次数为 9999")

#返回很多个,直接返回列表
re.findall(r"\d+","a=1,b=2")

#sub将匹配到的数据进行替换
re.sub(r"\d+","998","python=997")#998

例子:(阅读数迪加)

import re
def add(temp):
    strNum = temp.group()
    num = int(strNum)
    return str(num)
ret = re.sub(r"\d+",add,"python=997")
print(ret)
ret = re.sub(r"\d+",add,"python = 99")
print(ret)

#运行结果：
#python = 998
#python = 100
#$
#split()根据匹配进行切割字符串,并返回一个列表
需求：切割字符串“info:xiaoZhang 33 shandong”
#coding=utf-8
import re
#根据:和空格进行切
ret = re.split(r":|","info:xiaoZhang 33 shandong")
print(ret）
运行结果：
['info',"xiaoZhang', '33','shandong']


#$




#方法和属性重写
#在子类中重写父类方法属性会调用子类的
super().父类方法()#调用重写后父类方法
#$
#通过父类公有方法间接访问私有属性方法


#$
#对象私有属性方法,子类对象不能直接访问
class A:
    def __init__(self):#初始化方法
        self.num1=100#公有属性
        self.__num2=200#私有属性
    
    def __test(self):#私有方法
        print("私有方法"%d %d %(self.num1,self.__num2))

class B(A):
    #无法访问父类A的私有属性方法   

#$
#新式类(推荐使用)
#python3会默认继承object,python2不会
class A(object):#传object基类(python2传)
    pass

#$
#python中MRO 方法属性搜索顺序
print(C.__mro__)#查看属性方法搜索顺序,C为子类

#$
#类的多继承
#如果出现同名方法和属性避免使用多继承
class A:
    def a(self):
        print('a方法')

class B:
    def b(self):
        print('b方法')

class C(A,B):
    pass
#创建子类对象
c=C()
c.a()#调用方法
c.b()#调用方法

#判断当前代码是直接执行还是被其他调用
if __name__ == "__main__":
    print('ok')
    
#$
#设置递归层级次数,默认900层左右
sys.setrecursionlimit(10000)
#$


try:
    正常的操作
   ......................
except:#这里不写错误类型会捕捉所有异常
    发生异常，执行这块代码
   ......................
else:
    如果没有异常执行这块代码


#$
系统函数"
print()//输出打印
type()//查看类型
input("请输入内容:")//输入
int()//类型转换
float()//类型转换
#$
dir(对象名) #查看对象的所有方法属性
print(dir(a))
print(dir(a).__doc__)#查看注释文档
#$

#$
#内置方法(直接使用)
__new__  #对象创建时自动调用
__init__  #对象初始化时自动调用
__del__  #对象在内存中销毁时自动调用
__str__  #返回对象描述信息,print()输出使用


#类和对象定义使用
#类
class Cat:
    def eat(self):#内存地址self(this)必传,era(self,参数列表...)
        print("吃鱼")
        
tom=Cat()
tom.name="黑猫" #对象新增属性(不推荐外部新增属性)
tom.eat()

#$
%d  #十进制打印
%x  #十六进制打印
print("%d" % 123)
#$




#$
//算数优先级
**,*,/,%,//,+,-

#$
//算数运算符
+ (+法运算和字符串拼接)
-
* 1+1=2;"对不起"*100=  (数学运算和字符串运算)
/
// 取整数,返回除法的整数部分(商),9//2 输出4
% 取余数,返回除法的余数部分,9%2=1
** 冥数,又称次方,乘方,2**3=8(2的3次方)
#$

#$
//内核是系统的心脏,是运行程序管理硬件设施,如打印机和磁盘等核心程序,它提供了裸设备与应用程序的抽象层
#$
Linux终端命令
ls 当前文件夹下所有东西
ls -a 查看所有包括隐藏的
ls -l -h 以列表形式显示
ls -lh

适配符:
*所有,?单个,
ls 1* 显示所有以1开头的文件
ls *1.txt 显示所有以1.txt结尾的文件
ls *1* 显示所有以1结尾的


pwd 当前所在文件夹

cd,空格,目录名  切换文件夹
cd ~切换到当前用户主目录
cd .. 到上级目录
cd -最近两次目录之间来回切换

touch空格文件名 如果文件不存在,则创建文件,如果存在修改创建时间

mkdir 创建文件夹
mkdir -p a/b/ac 创建多级目录

rm删除后无法恢复
rm  删除指定的文件名
rm -r 文件夹名 删除指定的文件夹(递归目录删除)
rm -f 强制删除,不会报错,无提示
rm -r *删除所有
通配符配合使用
clear 清屏

command --help 查看command命令的使用帮助

man command 查看commadnd的使用手册

tree 树壮显示目录
tree ~ 显示家目录
three -d 只显示目录

复制文件
cp 源文件 新位置/文件名
cp ~/aa.txt ./b/c/ww.txt
cp ~/aa.txt .   
cp -i 覆盖文件前出现提示(n为no,y为yes)
cp -r 复制文件夹
scp (远程拷贝文件操作,和ssh地址参数相同-P端口大写)
scp -P poryt 1.py user@remote:Desktop/2.py


移动文件&文件夹
mv 源文件/文件夹 目标文件夹/文件
mv -i 覆盖文件前提示

文件或文件夹重命名(路径一样名称新)
mv 源文件 目标文件

查看文件内容
cat作用,显示所有内容
cat 文件名
cat -b 对非空输出行编号
cat -n 对所有编号
还有nl命令同上-b


more 文件名 显示一些,k空格显示下一页
Enter 一次看滚动一行,b回滚,f前滚,q退出,/word搜索，word字符串

grep 文本搜索(允许正则)
grep word 123.txt  (查找word)
grep -n word 123.txt  (显示行号)
-v 匹配不是的,-i忽略大小写
参数:
^a 行首,匹配a开头的行
ke$ 行尾,搜索以ke结尾的行

echo 往终端页面输入字符(配合重定向使用)

>或>>重定向,将内容输出或追加到指定文件中

>输出覆盖文件内容
>>追加内容

echo hello > a.txt
输出hello到a.txt中

ls -h > a.txt 把终端内容写到文件

管道 | （竖线）
将一个命令的输出通过管道作为另一个命令的输入(类似现实中水管)
实例：
ls -lha ~ | more 
ls -lha ~ | grep str 

远程管理关机重启：
shutdown (一分钟后关机;shutdown -c取消)
shutdown -r (重启)
shutdown -r -now (立即重启)
shutdown 20:20 (今天8:20关机)
shutdown +10   (10分钟后关机)
shutdown -c  (取消关机计划)
sudo shutdown -r now (超级用户身份)

网卡是网络通讯硬件设备,ip是设置在网卡上的地址信息
ifconfig 查看/配置当前计算机网卡配置信息
ifconfig | grep inet (inet开头的)
inet为ip地址


ping ip或域名 检测ip是否连接正常

ssh客户端使用
ssh [-p port] user@remote
-p
port是ssh服务器监听端口,默认22
user远程计算机上用户名,默认当前用户
remote远程地址,ip或域名


Windows中ssh需要安装putty或xshell

top 查看进程


目录操作：
自动补全：命令,空格,目录有歧义按2下,没有按一下tab

路径：绝对路径 / ,相对路径不加

Linux中同级目录下文件名和目录名不能重复







`;
export{
  python,
}

